Перейти к основному содержимому

5.17. Управляющие конструкции и операторы

ДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ
Разработчику Архитектору

Управляющие конструкции и операторы​

Выражения как основа управления​

В Haskell каждая конструкция является выражением, возвращающим значение. Это означает, что даже условные переходы, циклы и обработка ошибок не являются отдельными управляющими командами, а представляют собой выражения с определённым типом результата. Такой подход обеспечивает согласованность: любая часть программы может быть подставлена в другое место без изменения контекста, если совпадают типы. Управление потоком в Haskell — это выбор между различными значениями или путями вычислений, а не изменение состояния внешней среды.

Условные выражения: if-then-else​

Конструкция if-then-else в Haskell — это выражение, а не оператор. Она всегда требует наличия ветки else, поскольку каждое выражение должно иметь значение при любых условиях. Синтаксис:

if условие then выражение1 else выражение2

Здесь условие — булево значение типа Bool. Если условие истинно, результатом всего выражения становится выражение1; в противном случае — выражение2. Обе ветви обязаны иметь одинаковый тип, так как Haskell строго типизирован, и тип результата должен быть однозначно определён до выполнения.

Пример:

sign x = if x > 0 then 1 else if x < 0 then -1 else 0

Это выражение возвращает знак числа. Вложенность возможна, но для сложных случаев предпочтительны другие формы, такие как сопоставление с образцом или охранные выражения.

Сопоставление с образцом (Pattern Matching)​

Сопоставление с образцом — один из центральных механизмов управления в Haskell. Он позволяет разбирать структуры данных по их форме и связывать компоненты с переменными. Этот процесс происходит на уровне определения функций, в выражениях case, а также в лямбда-выражениях и привязках let/where.

При определении функции можно указать несколько уравнений с разными образцами. Haskell проверяет их сверху вниз и выбирает первое совпадающее. Например:

isZero 0 = True
isZero _ = False

Образец 0 соответствует только нулю, а _ — универсальный образец, совпадающий с любым значением. Порядок уравнений важен: более специфичные образцы должны идти перед общими.

Сопоставление работает с любыми алгебраическими типами данных. Для списков доступны образцы вида [] (пустой список) и (x:xs) (голова и хвост). Для кортежей — (a, b), для пользовательских типов — конструкторы с аргументами.

Пример с пользовательским типом:

data Shape = Circle Float | Rectangle Float Float

area :: Shape -> Float
area (Circle r) = pi * r * r
area (Rectangle w h) = w * h

Здесь функция area использует сопоставление с образцом, чтобы определить, какой конструктор использовался при создании значения, и применить соответствующую формулу.

Охранные выражения (Guards)​

Охранные выражения расширяют возможности сопоставления с образцом, позволяя добавлять булевы условия к каждому уравнению функции. Они записываются после вертикальной черты | и проверяются последовательно. Первое охранное выражение, вычисляющееся в True, определяет, какое тело функции будет выполнено.

Синтаксис:

функция аргументы
  | условие1 = результат1
  | условие2 = результат2
  ...
  | otherwise = результатN

Ключевое слово otherwise — это просто синоним True, гарантирующий, что хотя бы одно условие выполнится.

Пример:

grade :: Int -> String
grade score
  | score >= 90 = "Отлично"
  | score >= 75 = "Хорошо"
  | score >= 60 = "Удовлетворительно"
  | otherwise   = "Неудовлетворительно"

Охранные выражения особенно полезны, когда решение зависит от числовых сравнений или сложных логических условий, которые трудно выразить через образцы.

Конструкция case​

Выражение case обобщает сопоставление с образцом, позволяя использовать его в любом месте кода, а не только в определениях функций. Его синтаксис:

case выражение of
  образец1 -> результат1
  образец2 -> результат2
  ...

Haskell вычисляет выражение, затем последовательно сопоставляет его с каждым образцом, пока не найдёт совпадение. После этого выполняется соответствующее тело.

Пример:

describeList xs = "Список " ++ case xs of
  []     -> "пуст"
  [x]    -> "содержит один элемент"
  (x:_)  -> "начинается с " ++ show x

Выражение case является основой для многих других конструкций. Компилятор часто преобразует if-then-else, охранные выражения и даже определения функций с несколькими уравнениями в древовидные структуры на основе case.

Ленивые вычисления и управление потоком​

Haskell использует ленивую стратегию вычислений: выражения вычисляются только тогда, когда их значение действительно требуется. Это влияет на управляющие конструкции, делая их «ленивыми» по своей природе. Например, в выражении if condition then expensive else cheap функция expensive не будет вызвана, если condition ложно, даже если она содержит бесконечный цикл или дорогостоящую операцию.

Ленивость позволяет строить потенциально бесконечные структуры данных, такие как списки, и работать с ними эффективно. Управляющие конструкции автоматически учитывают эту особенность, выбирая только необходимые части данных.

Пример:

ones = 1 : ones
firstFive = take 5 ones  -- [1,1,1,1,1]

Здесь ones — бесконечный список, но take запрашивает только первые пять элементов, и остальная часть списка не вычисляется.

Последовательность действий: do-нотация​

В контексте монад, особенно IO, Haskell предоставляет do-нотацию для последовательного выполнения действий. Хотя язык остаётся чистым, do-блоки имитируют императивный стиль, связывая результаты предыдущих шагов с последующими.

Синтаксис:

do
  действие1
  x <- действие2
  действие3
  return результат

Каждая строка представляет собой монадическое действие. Оператор <- извлекает значение из монадического контекста и связывает его с переменной. Конструкция return помещает значение обратно в монаду, завершая последовательность.

Пример:

greet :: IO ()
greet = do
  putStrLn "Как вас зовут?"
  name <- getLine
  putStrLn ("Привет, " ++ name ++ "!")

Под капотом do-нотация преобразуется в цепочку вызовов оператора >>= (bind), что сохраняет чистоту языка и соответствие математической модели монад.

Логические и сравнительные операторы​

Haskell предоставляет стандартный набор операторов для логических и сравнительных операций. Все они являются функциями в инфиксной записи:

  • && — логическое И
  • || — логическое ИЛИ
  • not — логическое НЕ (префиксная функция)
  • == — равенство
  • /= — неравенство
  • <, <=, >, >= — числовые сравнения

Эти операторы часто используются в условиях if, охранных выражениях и фильтрах. Благодаря ленивости, && и || вычисляют правый операнд только при необходимости, что позволяет избежать лишних вычислений или ошибок.

Пример:

safeDivide :: Double -> Double -> Maybe Double
safeDivide x y
  | y /= 0    = Just (x / y)
  | otherwise = Nothing

Операторы композиции и применения​

Haskell активно использует функциональные операторы для управления потоком на уровне функций:

  • $ — оператор применения функции с низким приоритетом, позволяющий избежать скобок:

    f $ g x  -- эквивалентно f (g x)

  • . — оператор композиции функций:

    (f . g) x  -- эквивалентно f (g x)

Эти операторы позволяют строить конвейеры обработки данных, где выход одной функции становится входом другой. Такой стиль программирования подчёркивает декларативную природу Haskell: программа описывает, что нужно сделать, а не как это сделать шаг за шагом.

Пример:

result = map (+1) . filter even $ [1..10]

Это выражение сначала фильтрует чётные числа, затем увеличивает каждое на единицу.